unique_ptr< _Ty[], _Dx > Class Template Reference

Inheritance diagram for unique_ptr< _Ty[], _Dx >:

Public Types
typedef unique_ptr< _Ty[], _Dx >	_Myt
typedef _Unique_ptr_base< _Ty, _Dx >	_Mybase
typedef _Mybase::pointer	pointer
typedef _Ty	element_type
typedef _Dx	deleter_type
template<class _Uty >
using	_Enable_ctor_reset = enable_if_t< is_same< _Uty, pointer >::value||(is_same< pointer, element_type * >::value &&is_pointer< _Uty >::value &&is_convertible< remove_pointer_t< _Uty >(*)[], element_type(*)[] >::value)>
template<class _Uty , class _Ex , bool _More, class _UP_pointer = typename unique_ptr<_Uty, _Ex>::pointer, class _UP_element_type = typename unique_ptr<_Uty, _Ex>::element_type>
using	_Enable_conversion = enable_if_t< is_array< _Uty >::value &&is_same< pointer, element_type * >::value &&is_same< _UP_pointer, _UP_element_type * >::value &&is_convertible< _UP_element_type(*)[], element_type(*)[]>::value &&_More >
Public Types inherited from _Unique_ptr_base< _Ty, _Dx >
typedef remove_reference< _Dx >::type	_Dx_noref
typedef _Get_deleter_pointer_type< _Ty, _Dx_noref >::type	pointer

Public Member Functions
constexpr	unique_ptr () _NOEXCEPT
template<class _Uty , class = _Enable_ctor_reset<_Uty>>
	unique_ptr (_Uty _Ptr) _NOEXCEPT
template<class _Uty , class = _Enable_ctor_reset<_Uty>>
	unique_ptr (_Uty _Ptr, typename _If< is_reference< _Dx >::value, _Dx, const typename remove_reference< _Dx >::type & >::type _Dt) _NOEXCEPT
template<class _Uty , class = _Enable_ctor_reset<_Uty>>
	unique_ptr (_Uty _Ptr, typename remove_reference< _Dx >::type &&_Dt) _NOEXCEPT
	unique_ptr (unique_ptr &&_Right) _NOEXCEPT
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT
template<class _Uty , class _Ex , class = _Enable_conversion<_Uty, _Ex, is_reference<_Dx>::value ? is_same<_Ex, _Dx>::value : is_convertible<_Ex, _Dx>::value>>
	unique_ptr (unique_ptr< _Uty, _Ex > &&_Right) _NOEXCEPT
template<class _Uty , class _Ex , class = _Enable_conversion<_Uty, _Ex, is_assignable<_Dx&, _Ex&&>::value>>
_Myt &	operator= (unique_ptr< _Uty, _Ex > &&_Right) _NOEXCEPT
constexpr	unique_ptr (nullptr_t) _NOEXCEPT
_Myt &	operator= (nullptr_t) _NOEXCEPT
void	reset (nullptr_t=nullptr_t{}) _NOEXCEPT
void	swap (_Myt &_Right) _NOEXCEPT
	~unique_ptr () _NOEXCEPT
_Ty &	operator[] (size_t _Idx) const
pointer	get () const _NOEXCEPT
	operator bool () const _NOEXCEPT
pointer	release () _NOEXCEPT
template<class _Uty , class = _Enable_ctor_reset<_Uty>>
void	reset (_Uty _Ptr) _NOEXCEPT
	unique_ptr (const _Myt &)=delete
_Myt &	operator= (const _Myt &)=delete
Public Member Functions inherited from _Unique_ptr_base< _Ty, _Dx >
template<class _Ptr2 , class _Dx2 >
	_Unique_ptr_base (_Ptr2 _Ptr, _Dx2 &&_Dt)
template<class _Ptr2 >
constexpr	_Unique_ptr_base (_Ptr2 _Ptr)
_Dx &	get_deleter () _NOEXCEPT
const _Dx &	get_deleter () const _NOEXCEPT
pointer &	_Myptr () _NOEXCEPT
const pointer &	_Myptr () const _NOEXCEPT

Private Member Functions
void	_Delete ()

Additional Inherited Members
Public Attributes inherited from _Unique_ptr_base< _Ty, _Dx >
_Compressed_pair< _Dx, pointer >	_Mypair

Member Typedef Documentation

template<class _Ty , class _Dx >

template<class _Uty , class _Ex , bool _More, class _UP_pointer = typename unique_ptr<_Uty, _Ex>::pointer, class _UP_element_type = typename unique_ptr<_Uty, _Ex>::element_type>

using unique_ptr< _Ty[], _Dx >::_Enable_conversion = enable_if_t< is_array<_Uty>::value && is_same<pointer, element_type *>::value && is_same<_UP_pointer, _UP_element_type *>::value && is_convertible<_UP_element_type(*)[], element_type(*)[]>::value && _More>

template<class _Ty , class _Dx >

template<class _Uty >

using unique_ptr< _Ty[], _Dx >::_Enable_ctor_reset = enable_if_t< is_same<_Uty, pointer>::value || (is_same<pointer, element_type *>::value && is_pointer<_Uty>::value && is_convertible< remove_pointer_t<_Uty>(*)[], element_type(*)[] >::value)>

template<class _Ty , class _Dx >

typedef _Unique_ptr_base<_Ty, _Dx> unique_ptr< _Ty[], _Dx >::_Mybase

template<class _Ty , class _Dx >

typedef unique_ptr<_Ty[], _Dx> unique_ptr< _Ty[], _Dx >::_Myt

template<class _Ty , class _Dx >

typedef _Dx unique_ptr< _Ty[], _Dx >::deleter_type

template<class _Ty , class _Dx >

typedef _Ty unique_ptr< _Ty[], _Dx >::element_type

template<class _Ty , class _Dx >

typedef _Mybase::pointer unique_ptr< _Ty[], _Dx >::pointer

Constructor & Destructor Documentation

template<class _Ty , class _Dx >

constexpr unique_ptr< _Ty[], _Dx >::unique_ptr ( )

inline

        : _Mybase(pointer())
        {   // default construct
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
        }

template<class _Ty , class _Dx >

template<class _Uty , class = _Enable_ctor_reset<_Uty>>

unique_ptr< _Ty[], _Dx >::unique_ptr ( _Uty  _Ptr )

inlineexplicit

        : _Mybase(_Ptr)
        {   // construct with pointer
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
        }

template<class _Ty , class _Dx >

template<class _Uty , class = _Enable_ctor_reset<_Uty>>

unique_ptr< _Ty[], _Dx >::unique_ptr ( _Uty  _Ptr, typename _If< is_reference< _Dx >::value, _Dx, const typename remove_reference< _Dx >::type & >::type  _Dt  )

inline

        : _Mybase(_Ptr, _Dt)
        {   // construct with pointer and (maybe const) deleter&
        }

template<class _Ty , class _Dx >

template<class _Uty , class = _Enable_ctor_reset<_Uty>>

unique_ptr< _Ty[], _Dx >::unique_ptr ( _Uty  _Ptr, typename remove_reference< _Dx >::type &&  _Dt  )

inline

        : _Mybase(_Ptr, _STD move(_Dt))
        {   // construct by moving deleter
        static_assert(!is_reference<_Dx>::value,
            "unique_ptr constructed with reference to rvalue deleter");
        }

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::unique_ptr ( unique_ptr< _Ty[], _Dx > &&  _Right )

inline

        : _Mybase(_Right.release(),
            _STD forward<_Dx>(_Right.get_deleter()))
        {   // construct by moving _Right
        }

template<class _Ty , class _Dx >

template<class _Uty , class _Ex , class = _Enable_conversion<_Uty, _Ex, is_reference<_Dx>::value ? is_same<_Ex, _Dx>::value : is_convertible<_Ex, _Dx>::value>>

unique_ptr< _Ty[], _Dx >::unique_ptr ( unique_ptr< _Uty, _Ex > &&  _Right )

inline

            : _Mybase(_Right.release(),
                _STD forward<_Ex>(_Right.get_deleter()))
        {   // construct by moving _Right
        }

template<class _Ty , class _Dx >

constexpr unique_ptr< _Ty[], _Dx >::unique_ptr ( nullptr_t  )

inline

        : _Mybase(pointer())
        {   // null pointer construct
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
        }

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::~unique_ptr ( )

inline

        {   // destroy the object
        _Delete();
        }

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::unique_ptr ( const _Myt &  )

delete

Member Function Documentation

template<class _Ty , class _Dx >

void unique_ptr< _Ty[], _Dx >::_Delete ( )

inlineprivate

        {   // delete the pointer
        if (get() != pointer())
            this->get_deleter()(get());
        }

template<class _Ty , class _Dx >

pointer unique_ptr< _Ty[], _Dx >::get ( ) const

inline

        {   // return pointer to object
        return (this->_Myptr());
        }

template<class _Ty , class _Dx >

unique_ptr< _Ty[], _Dx >::operator bool ( ) const

inlineexplicit

        {   // test for non-null pointer
        return (get() != pointer());
        }

template<class _Ty , class _Dx >

_Myt& unique_ptr< _Ty[], _Dx >::operator= ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        if (this != &_Right)
            {   // different, do the swap
            reset(_Right.release());
            this->get_deleter() = _STD move(_Right.get_deleter());
            }
        return (*this);
        }

template<class _Ty , class _Dx >

template<class _Uty , class _Ex , class = _Enable_conversion<_Uty, _Ex, is_assignable<_Dx&, _Ex&&>::value>>

_Myt& unique_ptr< _Ty[], _Dx >::operator= ( unique_ptr< _Uty, _Ex > &&  _Right )

inline

        {   // assign by moving _Right
        reset(_Right.release());
        this->get_deleter() = _STD forward<_Ex>(_Right.get_deleter());
        return (*this);
        }

template<class _Ty , class _Dx >

_Myt& unique_ptr< _Ty[], _Dx >::operator= ( nullptr_t  )

inline

        {   // assign a null pointer
        reset();
        return (*this);
        }

template<class _Ty , class _Dx >

_Myt& unique_ptr< _Ty[], _Dx >::operator= ( const _Myt &  )

delete

template<class _Ty , class _Dx >

_Ty& unique_ptr< _Ty[], _Dx >::operator[] ( size_t  _Idx ) const

inline

        {   // return reference to object
        return (get()[_Idx]);
        }

template<class _Ty , class _Dx >

pointer unique_ptr< _Ty[], _Dx >::release ( )

inline

        {   // yield ownership of pointer
        pointer _Ans = get();
        this->_Myptr() = pointer();
        return (_Ans);
        }

template<class _Ty , class _Dx >

void unique_ptr< _Ty[], _Dx >::reset ( nullptr_t  = nullptr_t{} )

inline

                                    {}) _NOEXCEPT
        {   // establish new null pointer
        reset(pointer());
        }

template<class _Ty , class _Dx >

template<class _Uty , class = _Enable_ctor_reset<_Uty>>

void unique_ptr< _Ty[], _Dx >::reset ( _Uty  _Ptr )

inline

        {   // establish new pointer
        pointer _Old = get();
        this->_Myptr() = _Ptr;
        if (_Old != pointer())
            this->get_deleter()(_Old);
        }

template<class _Ty , class _Dx >

void unique_ptr< _Ty[], _Dx >::swap ( _Myt &  _Right )

inline

        {   // swap elements
        _Swap_adl(this->_Myptr(), _Right._Myptr());
        _Swap_adl(this->get_deleter(), _Right.get_deleter());
        }

---

The documentation for this class was generated from the following file:

• VS2015/inc/memory